Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@benchmarks/prompt_eval/eval_query_decomposition.py`:
- Around line 1-32: The default dataset filename is misspelled as
"query_decompostion" in multiple places; update every occurrence to
"query_decomposition" — specifically fix the docstring references and the
argparse default for the --dataset option (the string
"datasets/query_decompostion.json" and any plain "query_decompostion"
occurrences) so that the script loads datasets/query_decomposition.json by
default and no longer raises FileNotFoundError when run without --dataset.

In `@openrag/components/pipeline.py`:
- Around line 112-122: The current silent fallback that re-runs
self.retriever.retrieve without filters when docs is empty should be made
explicit and configurable: add a pipeline config flag (e.g.,
allow_filterless_fallback) and only perform the unfiltered re-query when that
flag is True; when you do fallback, set a metadata flag (e.g.,
filter_dropped=True) on the returned result (or attach to the docs/container) so
callers can surface that the temporal filter was dropped; replace the
logger.debug call with logger.warning or logger.info so it’s visible at INFO
level and include context (query=query.query, partition, reason); keep the
original retriever call parameters (partition, query.query, filter_params) when
not falling back and ensure all code paths return the same result shape
including the new metadata key.

In `@utility/data_indexer.py`:
- Around line 57-60: The deterministic file_id generation (absolute_path ->
file_id) now causes duplicate POSTs to url =
f"{args.url}/indexer/partition/{args.partition}/file/{file_id}" to return HTTP
409 and break reruns; update the uploader call in utility/data_indexer.py (the
block that posts to url) to treat 409 as non-fatal: catch the HTTP response or
exception from the POST, and if response.status_code == 409 (or the raised
HTTPError maps to 409), log an informative message and continue (skip that file)
instead of raising; otherwise preserve existing error handling for other status
codes so real failures still surface.

In `@utility/data_indexer2.py`:
- Around line 63-68: The try/except around fitz.open(file_path) currently
swallows all exceptions; change it to except Exception as e and log the failure
before falling back to page_count = 0 (e.g. logger.warning or logger.exception)
so operators can see why a PDF was skipped; update the block that calls
fitz.open(file_path) and sets page_count to capture the exception object (e) and
include file_path and e in the log message.

---

Outside diff comments:
In `@openrag/components/pipeline.py`:
- Around line 294-301: The web search is being called with a Query Pydantic
model instead of the raw string, which causes Query.__str__() to pollute the
search; update the web search invocations to pass the actual query string (use
q.query) rather than the Query object: change the web_tasks comprehension that
builds from queries.query_list to call self.web_search_service.search(q.query),
and make the identical change in the web-only branch where web_tasks is
constructed (the second occurrence near the other web-only logic).

In `@prompts/example1/spoken_style_answer_tmpl.txt`:
- Line 22: Fix the typo in the user-facing prompt template: in the prompt string
that begins "Keep your answer succinct and straight to the point as if speaking
to humain." (in spoken_style_answer_tmpl.txt / the "Keep your answer..."
prompt), change "humain" to "human" so the sentence reads "...speaking to
human."

---

Duplicate comments:
In `@utility/data_indexer2.py`:
- Around line 1-121: This file duplicates existing data_indexer.py and shouldn't
be upstream as-is; either remove it from the PR or rename it to reflect purpose
(e.g., pdf_benchmark_indexer.py) and refactor common logic (arg parsing,
__check_api, upload loop) into a shared helper module to prevent drift; if you
keep it, add a short docstring near the top declaring its benchmark intent and
justify the hard-coded limit = 100 and the page bounds check (the page_count <=
10 or page_count > 40 filter) so reviewers know they are intentional.

---

Nitpick comments:
In `@benchmarks/prompt_eval/eval_temporal_filter_generation.py`:
- Around line 55-230: Extract duplicated utilities and schemas into a shared
module (e.g., benchmarks/prompt_eval/_common.py): move _parse_env_list,
_build_models, _judge_config, _model_kwargs, build_llm_messages, format_prompt
and the Pydantic models TemporalPredicate, Query, SearchQueries (and any CLI
path-sandboxing helpers) into that module; then import and use them from
eval_temporal_filter_generation.py (and eval_query_decomposition.py) so both
files reference the single implementation; ensure imports/exports preserve names
and behavior (including default values like max_completion_tokens and any
langdetect fallback), run lints/tests, and update any relative references to
MODELS or judge_config usage to use the shared module.

In `@benchmarks/prompt_eval/prompts/query_contextualizer_tmpl_v1.txt`:
- Around line 31-42: The "past N" and "bare MONTH" rules are ambiguous: change
the "past N days/weeks/months/years → `[Current − N, tomorrow)`" line to
explicitly carry the time unit (e.g., "past N days/weeks/months/years →
`[Current − N {days|weeks|months|years}, tomorrow)`") and ensure "weeks" and
"months" are interpreted as whole-week and whole-month arithmetic (not unitless
subtraction). Clarify the "bare MONTH (no year) → nearest past occurrence" rule
by specifying deterministic behavior: if MONTH is before the current month use
MONTH of the current year; if MONTH is the current month or after, use MONTH of
the previous year (i.e., the most recent calendar occurrence strictly before
today). Ensure these exact phrases (the "past N days/weeks/months/years" rule
and the "bare MONTH (no year)" rule) are updated so models include the unit and
the tie-breaker rule unambiguously.

In `@benchmarks/prompt_eval/Report_query_decomposition.md`:
- Around line 50-63: The "Common hard cases (both models, both prompts)" bullet
list uses repetitive sentence openings and punctuation; please rewrite that
section (the header and the four bullets referencing id 30, id 63, id 70, id 74)
to vary sentence structure and lead-ins for readability — e.g., turn some
bullets into full sentences starting with the case description ("Compare AWS
Lambda and Google Cloud Functions") and others starting with the observed
failure ("Earlier gRPC turn..."), replace repeated em-dash openings with varied
connectors or clauses, and ensure each item still mentions the id and the
failure mode (single comparison, contaminated reformulation, under-splitting)
without changing meaning.

In `@openrag/components/pipeline.py`:
- Around line 73-77: The TemporalPredicate currently allows equality operators
but we only use ordered comparisons for TIMESTAMPTZ; update the type/definition
for the TemporalPredicate.operator (the Literal used where TemporalPredicate is
declared) to remove "==" and "!=" so only "<", ">", "<=", ">=" are permitted;
keep the to_milvus_filter() behavior (it can continue to emit ISO "..." strings)
and ensure any type hints or validations referencing TemporalPredicate.operator
(e.g., construction sites or validators) are updated to the narrower set.

In `@utility/data_indexer.py`:
- Around line 36-46: The __check_api function currently only raises on
httpx.RequestError and silently continues on non-200 responses; modify
__check_api to detect non-200 HTTP responses (e.g., call
response.raise_for_status() or explicitly check response.status_code != 200) and
raise an exception (or log and raise) so the caller fails fast; update the
try/except around httpx.get in __check_api to include HTTP status errors (using
response.raise_for_status() is preferred) so any 4xx/5xx result causes the
function to raise instead of returning silently.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@benchmarks/prompt_eval/.env.example`:
- Around line 2-4: The env var names BASE_URLs, API_KEYs, and MODELs in
.env.example are mixed-case and trigger dotenv-linter; either normalize them to
uppercase across all usages or add a linter exception: Option A — rename the
three variables to BASE_URLS, API_KEYS, and MODELS and update every reference in
eval_query_decomposition.py (references to BASE_URLs/API_KEYs/MODELs) and
eval_temporal_filter_generation.py (same three references) so they match; Option
B — add a .dotenv-linter.json rule to ignore these specific keys (BASE_URLs,
API_KEYs, MODELs) to suppress the warning if you want to keep the current names.

In `@benchmarks/prompt_eval/eval_query_decomposition.py`:
- Around line 192-204: format_prompt currently uses datetime.now(), making
outputs non-deterministic; change format_prompt to accept a reference_date (or
read a module-level DATASET_REFERENCE_DATE set to 2026-04-17) and use that date
to produce current_date (e.g., reference_date.strftime(...)) instead of
datetime.now(); update the other place that formats current_date (the similar
block at lines ~255-258) to also use the same reference_date or constant so all
relative-date prompt injections are deterministic and reproducible.

In `@openrag/config/models.py`:
- Line 422: Change the default for temporal retrieval to strict by setting the
Allow Filterless Fallback flag to False: update the attribute
allow_filterless_fallback in the ModelsConfig (symbol:
allow_filterless_fallback) from True to False and mirror the same default in
conf/config.yaml so both runtime model config and the YAML default are
consistent; ensure any documentation or initialization logic that reads
allow_filterless_fallback continues to work with the new False default.

In `@prompts/example1/query_contextualizer_tmpl.txt`:
- Around line 26-29: The example that maps content dates to a created_at filter
is incorrect: only emit temporal_filters (with field="created_at") when the user
explicitly refers to document creation/publication/written times; for user
requests about events/meetings held in a time window leave temporal_filters null
(or emit a separate event-time predicate if your schema supports it). Update the
example that rewrites “meetings held in the past month” so it does not produce
created_at predicates, and apply the same correction to the other similar
example that currently emits created_at; keep the half-open interval rule and
ISO8601 format for true created_at predicates.

---

Nitpick comments:
In `@benchmarks/prompt_eval/eval_query_decomposition.py`:
- Around line 335-355: The loop currently schedules every run_case concurrently
via asyncio.as_completed which can flood LLM endpoints; introduce a concurrency
limiter by creating an asyncio.Semaphore (configurable via a new --concurrency
CLI option) and wrap each run_case invocation in an async wrapper that acquires
the semaphore before calling run_case(case, ...) and releases it after, then
schedule those wrapper coroutines instead of raw run_case in tasks; keep the
tqdm/as_completed consumption the same but ensure tasks are created from the
semaphore-wrapped coroutine to bound simultaneous generator/judge calls.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@openrag/components/pipeline.py`:
- Around line 74-78: The Milvus filter builder in to_milvus_filter currently
emits expressions like ISO "..." which Milvus boolean grammar doesn't accept;
update the format in the list comprehension inside to_milvus_filter (where parts
is built from self.temporal_filters) to drop the "ISO " prefix and emit just the
quoted timestamp (e.g., f'{p.field} {p.operator} "{p.value}"'), then join parts
as before and return the resulting string.

---

Outside diff comments:
In `@openrag/components/pipeline.py`:
- Around line 303-342: The web search is being called with Query objects from
queries.query_list causing invalid search terms; update both places where
self.web_search_service.search is invoked (the web_tasks comprehension and the
inline search in web-only mode) to pass the raw string field (q.query) instead
of the Query object q so search receives a plain string; ensure any variable
names (e.g., web_tasks, raw_web_lists) remain compatible with this change.

---

Nitpick comments:
In `@openrag/components/pipeline.py`:
- Around line 115-128: When the code falls back to filterless retrieval (the if
block checking not docs and milvus_filter and self.allow_filterless_fallback),
add a machine-readable flag (e.g., filter_dropped: True) into the response
metadata so callers/UIs can detect that results no longer respect the original
temporal filter; set this flag on whatever response container you return from
this pipeline (or on each Document/DocsMetadata) immediately after docs = await
self.retriever.retrieve(...), using the same context (query.query, partition,
milvus_filter) so downstream code can surface a warning. Ensure the flag is only
present when this fallback path executes and preserved in the pipeline’s output
metadata structure.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@benchmarks/prompt_eval/eval_temporal_filter_generation.py`:
- Around line 128-139: The benchmark's TemporalPredicate model allows "==" and
"!=" but production's TemporalPredicate (openrag/components/pipeline.py) only
permits ">", "<", ">=", "<="; update the operator Literal in TemporalPredicate
in this file (class TemporalPredicate, field operator) to match production by
removing "==" and "!=" so it becomes Literal[">", "<", ">=", "<="], and make the
identical change to the copy in eval_query_decomposition.py so both benchmarks
mirror production validation and scoring.

In `@tests/api_tests/api_run/mock_vllm.py`:
- Around line 238-264: Handle enum/const and prevent infinite recursion: update
_mock_value to check for "const" and "enum" (return schema["const"] if present;
for "enum" return the first enum value that matches the expected type) before
the type branches so constrained strings (e.g., TemporalPredicate.op) are mocked
correctly; in _resolve_ref replace lstrip("#/") with removeprefix("#/") to
correctly strip JSON Pointer prefixes; add a simple cycle guard by threading a
visited set (e.g., visited_ids) through _resolve_ref and _mock_value to detect
and break recursive $ref loops (return None or a safe default when a cycle is
seen). Ensure you reference the existing function names _mock_value and
_resolve_ref when making changes.

---

Nitpick comments:
In `@openrag/components/pipeline.py`:
- Around line 211-273: The fallback chain currently only handles
openai.BadRequestError so schema/parse failures never trigger the
function_calling fallback; update the with_fallbacks call that builds
self.query_generator (primary, fallback, exceptions_to_handle) to also include
ValidationError and OutputParserException alongside openai.BadRequestError so
that schema validation/parsing errors will invoke the fallback path (references:
primary, fallback, self.query_generator, with_fallbacks, exceptions_to_handle,
ValidationError, OutputParserException, openai.BadRequestError).